<template>
    <u-popup
        :show="show"
        mode="bottom"
        closeable
        @close="close"
        :round="round"
        :closeOnClickOverlay="closeOnClickOverlay"
    >
        <view class="u-calendar">
            <uHeader
                :title="title"
                :showTitle="showTitle"
                :subtitle="subtitle"
                :showSubtitle="showSubtitle"
                :weekText="weekText"
            ></uHeader>
            <scroll-view
                :style="{
                    height: addUnit(listHeight)
                }"
                scroll-y
                @scroll="onScroll"
                :scroll-top="scrollTop"
                :scrollIntoView="scrollIntoView"
            >
                <uMonth
                    :color="color"
                    :rowHeight="rowHeight"
                    :showMark="showMark"
                    :months="months"
                    :mode="mode"
                    :maxCount="maxCount"
                    :startText="startText"
                    :endText="endText"
                    :defaultDate="defaultDate"
                    :minDate="innerMinDate"
                    :maxDate="innerMaxDate"
                    :maxMonth="monthNum"
                    :readonly="readonly"
                    :maxRange="maxRange"
                    :rangePrompt="rangePrompt"
                    :showRangePrompt="showRangePrompt"
                    :allowSameDay="allowSameDay"
                    :forbidDays="forbidDays"
                    :forbidDaysToast="forbidDaysToast"
                    ref="month"
                    @monthSelected="monthSelected"
                    @updateMonthTop="updateMonthTop"
                ></uMonth>
            </scroll-view>
            <slot name="footer" v-if="showConfirm">
                <view class="u-calendar__confirm">
                    <u-button
                        shape="circle"
                        :text="buttonDisabled ? confirmDisabledText : setBottomText"
                        :color="color"
                        @click="confirm"
                        :disabled="buttonDisabled"
                    ></u-button>
                </view>
            </slot>
        </view>
    </u-popup>
</template>

<script>
import uHeader from './header.vue'
import uMonth from './month.vue'
import { props } from './props.js'
import dayjs from 'dayjs/esm/index'
import Calendar from '../../libs/util/calendar.js'
import { mpMixin } from '../../libs/mixin/mpMixin.js'
import { mixin } from '../../libs/mixin/mixin.js'
import { addUnit, range, error, padZero } from '../../libs/function/index'
import test from '../../libs/function/test'
/**
 * 注释的代码都有关监听滚动的相关代码，后续需要根据需求进行移除或者保留
 * Calendar 日历
 * @event {Function()} confirm 		点击确定按钮时触发		选择日期相关的返回参数
 * @event {Function()} close 		日历关闭时触发			可定义页面关闭时的回调事件
 * @example <u-calendar :show="show" @confirm="confirm"></u-calendar>
 * */
export default {
    name: 'u-calendar-hj',
    mixins: [mpMixin, mixin, props],
    components: {
        uHeader,
        uMonth
    },
    data() {
        return {
            // 需要显示的月份的数组
            months: [],
            // 月份滚动区域的高度
            listHeight: 0,
            // month组件中选择的日期数组
            selected: [],
            // 在月份滚动区域中，当前视图中月份的index索引
            monthIndex: 0,
            // 滚动区的参数
            scrollIntoView: '',
            scrollIntoViewScroll: '',
            scrollTop: 0,
            isScroll: false,
            // 过滤处理方法
            innerFormatter: value => value
        }
    },
    watch: {
        selectedChange: {
            immediate: true,
            handler(n) {
                this.setMonth()
            }
        },
        // 打开弹窗时，设置月份数据
        show: {
            immediate: true,
            handler(n) {
                if (n) {
                    this.setMonth()
                } else {
                    // 关闭时重置scrollIntoView，否则会出现二次打开日历，当前月份数据显示不正确。
                    // scrollIntoView需要有一个值变动过程，才会产生作用。
                    this.scrollIntoView = ''
                }
            }
        }
    },
    computed: {
        // 由于maxDate和minDate可以为字符串(2021-10-10)，或者数值(时间戳)，但是dayjs如果接受字符串形式的时间戳会有问题，这里进行处理
        innerMaxDate() {
            return test.number(this.maxDate) ? Number(this.maxDate) : this.maxDate
        },
        innerMinDate() {
            return test.number(this.minDate) ? Number(this.minDate) : this.minDate
        },
        // 多个条件的变化，会引起选中日期的变化，这里统一管理监听
        selectedChange() {
            return [this.innerMinDate, this.innerMaxDate, this.defaultDate]
        },
        // 副标题内容处理
        subtitle() {
            // 初始化时，this.months为空数组，所以需要特别判断处理
            if (this.months.length) {
                return `${this.months[this.monthIndex].year}年${
                    this.months[this.monthIndex].month
                }月`
            } else {
                return ''
            }
        },
        buttonDisabled() {
            // 如果为range类型，且选择的日期个数不足1个时，让底部的按钮出于disabled状态
            if (this.mode === 'range') {
                if (this.selected.length <= 1) {
                    return true
                } else {
                    return false
                }
            } else {
                return false
            }
        },
        // 更改底部选择区间后的文字 增加统计显示
        setBottomText() {
            if (this.selected.length >= 2) {
                let day = dayjs(this.selected[this.selected.length - 1]).diff(
                    this.selected[0],
                    'day'
                )
                let text = day ? ` (入住${day}晚)` : ''
                return `${this.confirmText}${text}`
            }
            return this.confirmText
        }
    },
    mounted() {
        this.init()
    },
    emits: ['confirm', 'close'],
    methods: {
        addUnit,
        // 在微信小程序中，不支持将函数当做props参数，故只能通过ref形式调用
        setFormatter(e) {
            this.innerFormatter = e
        },
        init() {
            // 校验maxDate，不能小于minDate。
            if (
                this.innerMaxDate &&
                this.innerMinDate &&
                new Date(this.innerMaxDate).getTime() < new Date(this.innerMinDate).getTime()
            ) {
                return error('maxDate不能小于minDate时间')
            }
            // 滚动区域的高度
            this.listHeight = this.rowHeight * 6 + 30
            this.setMonth()
        },
        close() {
            this.$emit('close')
        },
        // 点击确定按钮
        confirm() {
            if (!this.buttonDisabled) {
                let selected = this.selected
                let days
                if (this.mode === 'range') {
                    days = dayjs(selected[selected.length - 1]).diff(selected[0], 'day')
                }
                // 是否需要返回全部的选中日期
                if (this.returnAllSelectedDate && this.mode === 'range') {
                    this.$emit('confirm', {
                        date: this.getCenterDate(selected),
                        nightsCount: days > 0 ? days : ''
                    })
                } else {
                    this.$emit('confirm', {
                        date: selected,
                        nightsCount: days > 0 ? days : ''
                    })
                }
            }
        },
        // 需要查询选中日期之间的全部日期
        getCenterDate(selected) {
            const startDate = selected[0]
            const endDate = selected[1]
            const arr = []
            let i = 0
            do {
                // 将开始和结束日期之间的日期添加到数组中
                arr.push(dayjs(startDate).add(i, 'day').format('YYYY-MM-DD'))
                i++
                // 累加的日期小于结束日期时，继续下一次的循环
            } while (dayjs(startDate).add(i, 'day').isBefore(dayjs(endDate)))
            // 为了一次性修改数组，避免computed中多次触发，这里才用arr变量一次性赋值的方式，同时将最后一个日期添加进来
            arr.push(endDate)
            return arr
        },
        // month组件内部选择日期后，通过事件通知给父组件
        monthSelected(e, scene = 'init') {
            this.selected = e
            if (!this.showConfirm) {
                // 在不需要确认按钮的情况下，如果为单选，或者范围多选且已选长度大于2，则直接进行返还
                if (
                    this.mode === 'multiple' ||
                    this.mode === 'single' ||
                    (this.mode === 'range' && this.selected.length >= 2)
                ) {
                    if (scene === 'init') {
                        return
                    }
                    if (scene === 'tap') {
                        this.$emit('confirm', this.selected)
                    }
                }
            }
        },
        // 获得两个日期之间的月份数
        getMonths(minDate, maxDate) {
            const minYear = dayjs(minDate).year()
            const minMonth = dayjs(minDate).month() + 1
            const maxYear = dayjs(maxDate).year()
            const maxMonth = dayjs(maxDate).month() + 1
            return (maxYear - minYear) * 12 + (maxMonth - minMonth) + 1
        },
        // 设置月份数据
        setMonth() {
            // 最小日期的毫秒数
            const minDate = this.innerMinDate || dayjs().valueOf()
            // 如果没有指定最大日期，则往后推默认的月数
            const maxDate =
                this.innerMaxDate ||
                dayjs(minDate)
                    .add(this.monthNum - 1, 'month')
                    .valueOf()
            // 最大最小月份之间的共有多少个月份，
            const months = range(1, this.monthNum, this.getMonths(minDate, maxDate))
            // 先清空数组
            this.months = []
            for (let i = 0; i < months; i++) {
                this.months.push({
                    // .fill(1)参数可随意填写（不为空），主要是map函数中返回的数据
                    date: new Array(dayjs(minDate).add(i, 'month').daysInMonth())
                        .fill(1)
                        .map((item, index) => {
                            // 日期，取值1-31
                            let day = index + 1
                            // 星期，0-6，0为周日
                            const week = dayjs(minDate).add(i, 'month').date(day).day()
                            const date = dayjs(minDate)
                                .add(i, 'month')
                                .date(day)
                                .format('YYYY-MM-DD')
                            let bottomInfo = ''
                            if (this.showLunar) {
                                // 将日期转为农历格式
                                const lunar = Calendar.solar2lunar(
                                    dayjs(date).year(),
                                    dayjs(date).month() + 1,
                                    dayjs(date).date()
                                )
                                bottomInfo = lunar.IDayCn
                            }
                            // 日期对象，供外部的formatter获取当前日期的年月日等信息，进行加工处理
                            let config = {
                                day,
                                week,
                                //如果需要价格到时候需要请求接口，最好一个接口返回所有日期的价格，然后根据日期进行比对赋值
                                price: '128.00',
                                // 小于最小允许的日期，或者大于最大的日期，则设置为disabled状态
                                disabled:
                                    dayjs(date).isBefore(dayjs(minDate).format('YYYY-MM-DD')) ||
                                    dayjs(date).isAfter(dayjs(maxDate).format('YYYY-MM-DD')),
                                // 返回一个日期对象，供外部的formatter获取当前日期的年月日等信息，进行加工处理
                                date: new Date(date),
                                bottomInfo,
                                dot: false,
                                month: dayjs(minDate).add(i, 'month').month() + 1
                            }
                            const formatter = this.formatter || this.innerFormatter
                            return formatter(config)
                        }),
                    // 当前所属的月份
                    month: dayjs(minDate).add(i, 'month').month() + 1,
                    // 当前年份
                    year: dayjs(minDate).add(i, 'month').year()
                })
            }
            // 当设置了 defaultDate 时，滚动到对应月份
            if (this.defaultDate) {
                let targetDate = Array.isArray(this.defaultDate)
                    ? this.defaultDate[0]
                    : this.defaultDate
                targetDate = dayjs(targetDate).format('YYYY-MM')
                this.scrollIntoDefaultMonth(targetDate)
            }
        },

        // 如果后续不需要副标题变化可以不监听滚动，比较消耗性能
        // 滚动到默认设置的月份
        scrollIntoDefaultMonth(selected) {
            // 查询默认日期在可选列表的下标
            const _index = this.months.findIndex(({ year, month }) => {
                month = padZero(month)
                return `${year}-${month}` === selected
            })
            if (_index !== -1) {
                // #ifndef MP-WEIXIN
                this.$nextTick(() => {
                    this.scrollIntoView = `month-${_index}`
                    this.scrollIntoViewScroll = this.scrollIntoView
                })
                // #endif
                // #ifdef MP-WEIXIN
                this.scrollTop = this.months[_index].top || 0
                // #endif
            }
        },
        // scroll-view滚动监听
        onScroll(event) {
            // 不允许小于0的滚动值，如果scroll-view到顶了，继续下拉，会出现负数值
            const scrollTop = Math.max(0, event.detail.scrollTop)
            if (
                !this.isScroll &&
                this.defaultDate[0] &&
                this.mode === 'range' &&
                dayjs(this.defaultDate[0]).format('YYYY-MM') !== dayjs().format('YYYY-MM')
            ) {
                // 拿到当前选中的第一个日期是在第几行
                const monthStart = dayjs(this.defaultDate[0]).format('YYYY-MM') + '-01'
                const week = dayjs(monthStart).day()
                const count = week === 0 ? 6 : week - 1
                const line = Math.floor(
                    (Number(dayjs(this.defaultDate[0]).format('DD')) + count - 1) / 7
                )
                this.isScroll = true
                if (line > 1) {
                    this.scrollTop = scrollTop + 56 * (line - 1) + 42
                }
            }
            // 将当前滚动条数值，除以滚动区域的高度，可以得出当前滚动到了哪一个月份的索引
            for (let i = 0; i < this.months.length; i++) {
                if (scrollTop >= (this.months[i].top || this.listHeight)) {
                    this.monthIndex = i
                    this.scrollIntoViewScroll = `month-${i}`
                }
            }
        },
        // 更新月份的top值
        updateMonthTop(topArr = []) {
            // 设置对应月份的top值，用于onScroll方法更新月份
            topArr.map((item, index) => {
                this.months[index].top = item
            })

            // 获取默认日期的下标
            if (!this.defaultDate) {
                // 如果没有设置默认日期，则将当天日期设置为默认选中的日期
                const selected = dayjs().format('YYYY-MM')
                this.scrollIntoDefaultMonth(selected)
                return
            }
            let selected = dayjs().format('YYYY-MM')
            // 单选模式，可以是字符串或数组，Date对象等
            if (!test.array(this.defaultDate)) {
                selected = dayjs(this.defaultDate).format('YYYY-MM')
            } else {
                selected = dayjs(this.defaultDate[0]).format('YYYY-MM')
            }
            this.scrollIntoDefaultMonth(selected)
        }
    }
}
</script>

<style lang="scss" scoped>
@import '../../libs/css/components.scss';

.u-calendar {
    &__confirm {
        padding: 10px 18px;
        padding-bottom: 40rpx;
    }
}
</style>
